/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package business;

import dao.CursoDao;
import dao.EstudianteDao;
import dominio.Curso;
import dominio.Estudiante;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.StringTokenizer;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.swing.JTable;

/**
 *
 * @author vanessa
 */
public class EstudianteBO {

    EstudianteDao estudiantedao;
    CursoDao cursodao;
/**
 * Este metodo registra a un estudiante como preinscrito
 * solicitando los datos necesarios para la tarea. Si la
 * operacion es exitosa, se devuelve true, sino, retorna false.
 *
 * @param nombres
 * @param apellidos
 * @param idgrado
 * @param telefono
 * @param docidentidad
 * @param genero
 * @param edad
 * @param direcion
 * @return
 */
 public boolean preinscribirEstudiante(String nombres,
                                       String apellidos,
                                       String idgrado,  //el id lo enviara la clase control correspondiente
                                       int telefono,
                                       long docidentidad,
                                       String genero,
                                       String direcion,
                                       String nombremadre,
                                       String apellidomadre,
                                       long documentomadre,
                                       String nombrepadre,
                                       String apellidopadre,
                                       long documentopadre,
                                       String fechanacimiento){

    EntityManagerFactory emf =
    Persistence.createEntityManagerFactory("SiaPersistencia");
    EntityManager em = emf.createEntityManager();
    estudiantedao = new EstudianteDao(em);
    cursodao = new CursoDao();
    //algoritmo para encontrar curso libre, como eso es de aula, no es mi responsabilidad xD
    //asi que por ahora, lo asigna al primer curso encontrado
    em.getTransaction().begin();
    
    if(!cursodao.encontrarCursosPorGrado(1).isEmpty()){
        Collection<Curso> listacursos=cursodao.encontrarCursosPorGrado(/*Integer.valueOf(idgrado)*/1);
       
        estudiantedao.crearEstudianteEnPreinscripcion(nombres,
                                                      apellidos,
                                                      listacursos.iterator().next().getNombreCurso(),            //idcurso
                                                      Integer.valueOf(idgrado),                   //idgrado
                                                      telefono,
                                                      docidentidad,
                                                      genero,
                                                      direcion,
                                                      nombremadre,
                                                      apellidomadre,
                                                      documentomadre,
                                                      nombrepadre,
                                                      apellidopadre,
                                                      documentopadre,
                                                      fechanacimiento,
                                                      String.valueOf(0));            //Cambiar si administador elige el id
        em.getTransaction().commit();
        em.close(); //quitar cuando se tenga montado el serv
        emf.close();//quitar cuando se tenga montado el serv
        return true;
        }
        else{
            return false;
        }
    }

 /**
  * Retorna un arreglo de tipo Estudiante, con los estudiantes preinscritos en orden
  * cronologico (de el preinscrito mas antiguo al preinscrito mas reciente
  *
  * @return Estudiante[] con el listado de preinscritos.
  */
    public List obtenerListadoPreinscritos() {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("SiaPersistencia");
        EntityManager em = emf.createEntityManager();
        estudiantedao = new EstudianteDao(em);
        em.getTransaction().begin();
        List lista=null;               //coleccion de objetos con atributos de preinscrito
        lista=estudiantedao.EncontrarEstudiantesPreinscritos();
        em.close(); //quitar cuando se tenga montado el serv
        emf.close();//quitar cuando se tenga montado el serv

        return lista;
    }

    /**
     * esta funcion cambia el listado de estudiantes de preinscritos a inscritos
     * y devuelve el numero de estudiantes inscritos
     */
    public int actualizarAInscritos(JTable tablaentrada){
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("SiaPersistencia");
        EntityManager em = emf.createEntityManager();
        estudiantedao = new EstudianteDao(em);
        int retorno = 0;

        for(int iterador=0;iterador<tablaentrada.getRowCount();iterador++) {
            if(tablaentrada.getValueAt(iterador, 5).equals("si")||
                    tablaentrada.getValueAt(iterador, 5).equals("s")||
                    tablaentrada.getValueAt(iterador, 5).equals("S")||
                    tablaentrada.getValueAt(iterador, 5).equals("SI")) {
                System.out.println((Long) tablaentrada.getValueAt(iterador, 0));
                estudiantedao.ActualizarEstudianteAInscrito((Long) tablaentrada.getValueAt(iterador, 0));           //columna 0, columna con numero de identidad
                retorno++;
            }
        }

        em.close(); //quitar cuando se tenga montado el serv
        emf.close();//quitar cuando se tenga montado el serv
        return retorno;
    }

    //funcion que matricula a estudiantes y devuelve el numero de estudiantes que matriculo
    public int actualizarAMatriculados(JTable tablaentrada) {
        EntityManagerFactory emf =
        Persistence.createEntityManagerFactory("SiaPersistencia");
        EntityManager em = emf.createEntityManager();
        estudiantedao = new EstudianteDao(em);

        int retorno=0;

        for(int iterador=0;iterador<tablaentrada.getRowCount();iterador++)
        {
            if(tablaentrada.getValueAt(iterador, 5).equals("si")||
               tablaentrada.getValueAt(iterador, 5).equals("s")||
               tablaentrada.getValueAt(iterador, 5).equals("S")||
               tablaentrada.getValueAt(iterador, 5).equals("SI")) {

                 System.out.println((Long) tablaentrada.getValueAt(iterador, 0));
                 estudiantedao.ActualizarEstudianteAMatriculado((Long) tablaentrada.getValueAt(iterador, 0));           //columna 0, columna con numero de identidad
                 retorno++;
             }
        }
        em.close(); 
        emf.close();
        return retorno;
    }

    public List<Estudiante> obtenerListadoMatriculados() {
        EntityManagerFactory emf =
        Persistence.createEntityManagerFactory("SiaPersistencia");
        EntityManager em = emf.createEntityManager();
        estudiantedao = new EstudianteDao(em);
        em.getTransaction().begin();

        List lista=null;               //coleccion de objetos con atributos de preinscrito
        lista=estudiantedao.EncontrarEstudiantesMatriculados();
        em.close(); //quitar cuando se tenga montado el serv
        emf.close();//quitar cuando se tenga montado el serv

        return lista;
    }

    public List<Estudiante> obtenerListadoInscritos() {
        EntityManagerFactory emf =
        Persistence.createEntityManagerFactory("SiaPersistencia");
        EntityManager em = emf.createEntityManager();
        estudiantedao = new EstudianteDao(em);
        em.getTransaction().begin();

        List lista=null;               //coleccion de objetos con atributos de preinscrito
        lista=estudiantedao.EncontrarEstudiantesInscritos();
        em.close(); //quitar cuando se tenga montado el serv
        emf.close();//quitar cuando se tenga montado el serv

        return lista;
    }
    
    /**
     * Verifica que el documento de identidad de un estudiante no se
     * encuentre actualmente registrado, puesto que este valor debe
     * ser unico para cada estudiante.
     *
     * @param int documento
     *
     * @return true si encuentra un numero de documento de
     * estudiante repetido.
     *
     * @return false si no encuentra repeticion en los documentos
     * de identidad.
     */
    public boolean verificarDocumentoRepetido(long documento){
        EntityManagerFactory emf =
        Persistence.createEntityManagerFactory("SiaPersistencia");
        EntityManager em = emf.createEntityManager();
        estudiantedao = new EstudianteDao(em);
        boolean retorno=estudiantedao.verificarDocumentoYaRegistrado(documento);
        em.close(); //quitar cuando se tenga montado el serv
        emf.close();//quitar cuando se tenga montado el serv
        return retorno;
    }

    /**
     * Toma la fecha de nacimiento como String y devuelve la edad en años
     * deacuerdo a la fecha ingresada.
     *
     * @param fechanacimiento  de estudiante
     * @return
     */
    public int calcularEdad(String fechanacimiento){
        int edad = 0;
        StringTokenizer temporal= new StringTokenizer(fechanacimiento);
        int añotemp=Integer.parseInt(temporal.nextToken("/"));
        int mestemp=Integer.parseInt(temporal.nextToken("/"));
        int diatemp=Integer.parseInt(temporal.nextToken("/"));

        Date actual=new Date();
        edad+=añotemp;
        if((mestemp>=actual.getMonth()&&diatemp>=actual.getDay())||mestemp>actual.getMonth())
            return edad=+1;
        else
            return edad;
    }

    public Estudiante obtenerEstudiantePorDocumento(long documento){
        EntityManagerFactory emf =
        Persistence.createEntityManagerFactory("SiaPersistencia");
        EntityManager em = emf.createEntityManager();
        estudiantedao = new EstudianteDao(em);
        Estudiante encontrarEstudiantePorDocumento = null;
        encontrarEstudiantePorDocumento=this.clonarEstudiante(estudiantedao.encontrarEstudiantePorDocumento(documento),
                              encontrarEstudiantePorDocumento);
        System.out.println("clona el objeto");
        /*Estudiante encontrarEstudiantePorDocumento = estudiantedao.encontrarEstudiantePorDocumento(documento);*/
        em.close(); //quitar cuando se tenga montado el serv
        emf.close();//quitar cuando se tenga montado el serv
        return encontrarEstudiantePorDocumento;
    }

    /**
     * Esta funcion recibe los datos personales de estudiante para actualizarlos
     * en loa base de datos.
     *
     * Los datos que actualiza son:
     *
     * @param nombre
     * @param apellido
     * @param telefono
     * @param fechanacimiento
     * @param direccion
     * @return true si tiene exito, false sino
     */
    public boolean actualizarDatosPersonales(long docidentidadviejo,
                                             String docidentidadnuevo,
                                             String nombre,
                                             String apellido,
                                             String telefono,
                                             String fechanacimiento,
                                             String direccion){

        EntityManagerFactory emf =
        Persistence.createEntityManagerFactory("SiaPersistencia");
        EntityManager em = emf.createEntityManager();
        estudiantedao = new EstudianteDao(em);
        boolean retorno=estudiantedao.actualizarDatosPersonales(docidentidadviejo,
                                                                docidentidadnuevo,
                                                                nombre,
                                                                apellido,
                                                                Integer.valueOf(telefono),
                                                                fechanacimiento,
                                                                direccion);
        em.close(); //quitar cuando se tenga montado el serv
        emf.close();//quitar cuando se tenga montado el serv
        return retorno;
    }

    private Estudiante clonarEstudiante(Estudiante entrada,Estudiante salida){
        if(entrada==null){
            return null;
        }
        else
        {
            salida= new Estudiante();
            salida.setIdEstudiante(entrada.getIdEstudiante());
            salida.setIdCurso(entrada.getIdCurso());
            salida.setIdGrado(entrada.getIdGrado());
            salida.setNombrePadre(entrada.getNombrePadre());
            salida.setApellidoPadre(entrada.getApellidoPadre());
            salida.setDocPadre(entrada.getDocPadre());
            salida.setTelPadre(entrada.getTelPadre());
            salida.setNombreMadre(entrada.getNombreMadre());
            salida.setApellidoMadre(entrada.getApellidoMadre());
            salida.setDocMadre(entrada.getDocMadre());
            salida.setTelMadre(entrada.getTelMadre());
            salida.setNombreUsuario(entrada.getNombreUsuario());
            salida.setDocEstudiante(entrada.getDocEstudiante());
            salida.setNombreEst(entrada.getNombreEst());
            salida.setApellidoEst(entrada.getApellidoEst());
            salida.setTelefonoEst(entrada.getTelefonoEst());
            salida.setGeneroEst(entrada.getGeneroEst());
            salida.setDireccionEst(entrada.getDireccionEst());
            salida.setFechaNacimientoEst(entrada.getFechaNacimientoEst());
            salida.setPreInscrito(entrada.getPreInscrito());
            salida.setInscrito(entrada.getInscrito());
            salida.setMatriculado(entrada.getMatriculado());
            salida.setAnoIngreso(entrada.getAnoIngreso());
            salida.setFechaPreinscripcion(entrada.getFechaPreinscripcion());

            return salida;
        }
    }

    public boolean actualizarDatosDePadre(long docidentidadviejo,String nombre, String apellido, String documento, String telefono) {
        EntityManagerFactory emf =
        Persistence.createEntityManagerFactory("SiaPersistencia");
        EntityManager em = emf.createEntityManager();
        estudiantedao = new EstudianteDao(em);
        boolean retorno=estudiantedao.actualizarDatosDePadre(docidentidadviejo,
                                                             nombre,
                                                             apellido,
                                                             Long.valueOf(documento),
                                                             Integer.valueOf(telefono));
        em.close(); //quitar cuando se tenga montado el serv
        emf.close();//quitar cuando se tenga montado el serv
        return retorno;
    }

    public boolean actualizarDatosDeMadre(long docidentidadviejo,String nombre, String apellido, String documento, String telefono) {
        EntityManagerFactory emf =
        Persistence.createEntityManagerFactory("SiaPersistencia");
        EntityManager em = emf.createEntityManager();
        estudiantedao = new EstudianteDao(em);
        boolean retorno=estudiantedao.actualizarDatosDeMadre(docidentidadviejo,
                                                             nombre,
                                                             apellido,
                                                             Long.valueOf(documento),
                                                             Integer.valueOf(telefono));
        em.close(); 
        emf.close();
        return retorno;
    }

    public Collection<Estudiante> encontrarEstudiantesSinUsuario() {
        EntityManagerFactory emf =
        Persistence.createEntityManagerFactory("SiaPersistencia");
        EntityManager em = emf.createEntityManager();
        estudiantedao = new EstudianteDao(em);
        Collection<Estudiante> e= estudiantedao.encontrarEstudiantesSinUsuario();
        emf.close();
        return e;

    }

    public Collection<Estudiante> encontrarEstudiantesConUsuario() {
        EntityManagerFactory emf =
        Persistence.createEntityManagerFactory("SiaPersistencia");
        EntityManager em = emf.createEntityManager();
        estudiantedao = new EstudianteDao(em);
        Collection<Estudiante> e= estudiantedao.encontrarEstudiantesConUsuario();
        emf.close();
        return e;

    }

    public void asignarUsuarioAEstudiante(Long docEst, String nombreUsuario) {
        EntityManagerFactory emf =
        Persistence.createEntityManagerFactory("SiaPersistencia");
        EntityManager em = emf.createEntityManager();
        estudiantedao = new EstudianteDao(em);
        estudiantedao.asignarUsuarioAEstudiante(docEst, nombreUsuario);
        em.close();
        emf.close();

    }

    public boolean cambiarEstudianteDeCurso(String idCurso, long docestudiante){
        EntityManagerFactory emf =
        Persistence.createEntityManagerFactory("SiaPersistencia");
        EntityManager em = emf.createEntityManager();
        estudiantedao = new EstudianteDao(em);
        boolean retorno=estudiantedao.cambiarEstudianteDeCurso(idCurso, docestudiante);
        em.close(); //quitar cuando se tenga montado el serv
        emf.close();//quitar cuando se tenga montado el serv
        return retorno;
    }

    public Collection<Estudiante> encontrarEstudiantesPorGradoPreinscritos(String idgrado){
        EntityManagerFactory emf =
        Persistence.createEntityManagerFactory("SiaPersistencia");
        EntityManager em = emf.createEntityManager();
        estudiantedao = new EstudianteDao(em);
        List<Estudiante> retorno=estudiantedao.encontrarEstudiantesPorGradoPreinscrito(idgrado);
        em.close(); //quitar cuando se tenga montado el serv
        emf.close();//quitar cuando se tenga montado el serv
        return retorno;
   }

   public List<Estudiante> encontrarEstudiantesPorGradoInscritos(String idgrado) {
        EntityManagerFactory emf =
        Persistence.createEntityManagerFactory("SiaPersistencia");
        EntityManager em = emf.createEntityManager();
        estudiantedao = new EstudianteDao(em);
        List<Estudiante> listaretorno=estudiantedao.encontrarEstudiantesPorGradoInscrito(idgrado);
        em.close();
        emf.close();
        return listaretorno;
    }

    public List<Estudiante> encontrarEstudiantesAsignadosAGrado(String idgrado){
        EntityManagerFactory emf =
        Persistence.createEntityManagerFactory("SiaPersistencia");
        EntityManager em = emf.createEntityManager();
        estudiantedao = new EstudianteDao(em);
        List<Estudiante> listaretorno=estudiantedao.encontrarEstudiantesPorGradoMatriculado(idgrado);
        em.close();
        emf.close();
        return listaretorno;
    }

    public List<Estudiante> encontrarEstudiantesAsignadosACurso(String idcurso){
        EntityManagerFactory emf =
        Persistence.createEntityManagerFactory("SiaPersistencia");
        EntityManager em = emf.createEntityManager();
        estudiantedao = new EstudianteDao(em);
        List<Estudiante> listaretorno=estudiantedao.encontrarEstudiantesPorCursoMatriculado(idcurso);
        em.close();
        emf.close();
        return listaretorno;
   }

    public List<Estudiante> buscarEstudiantesPorNombre(String nombreIngresado) {
        EstudianteBO estudiantebo = new EstudianteBO();
        List<Estudiante> listaEncontrados = estudiantebo.obtenerListadoMatriculados();
        for (Iterator<Estudiante> it = listaEncontrados.iterator(); it.hasNext();) {
            Estudiante estudiante = it.next();
            String nombre = estudiante.getNombreEst();
            if (!(nombre.contains(nombreIngresado))){
                listaEncontrados.remove(estudiante);
            }
        }
        return listaEncontrados;
    }
    public List<Estudiante> buscarEstudiantesPorCodigo(String codigoIngresado) {
        EstudianteBO estudiantebo = new EstudianteBO();
        List<Estudiante> listaEncontrados = estudiantebo.obtenerListadoMatriculados();
        for (Iterator<Estudiante> it = listaEncontrados.iterator(); it.hasNext();) {
            Estudiante estudiante = it.next();
            String codigo = estudiante.getIdEstudiante() + "";
            if (!(codigo.contains(codigoIngresado))){
                listaEncontrados.remove(estudiante);
            }
        }
        return listaEncontrados;
    }
}
